﻿// DatastructInCLanguage.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
// 《数据结构 C语言实现》 ISBN 978-7-111-66066-8 这书写的一言难尽。。。
//【第一章】算法 最大公约数 greatest common divisor gcd ()
//gcd (a,b) = gcd(b,a mod b)
//两个数相除 公约数里面最大的一个。
//有穷性  确定性    可行性  输入 输出。
//算法分析：
// 时间复杂度 Time Complexity  T(n) = O(f(n))  基本操作语句贡献最大的语句执行的
// 次数是问题规模n的某个函数，记作f(n)。
// 空间复杂度 S(n) = O(f(n))
// n 为问题的规模，f(n)为语句关于n的所占存储空间的函数。
//一般情况下，一个程序在机器上执行时，除了需要存储程序本身的指令、常数、变量、和输入数据外。
//还需要存储对数据操作的存储单元。
//若输入数据所占空间值取决于问题本身，和算法无关，这样我们只需要分析该算法在实现时所需要的辅助单元即可。
//若算法执行时所需要的辅助空间相对于输入数据而言是个常数，则称此算法为原地工作。空间复杂度为O(1).
//一般递归为常数阶。S(n)  = O(n).
//
//
//#include<stdio.h>
//int gcd(int a,int b)
//{
//	return (b==0)? a : gcd(b, a % b);
//}
//int main()
//{
//	int m, n, r=1;
//	printf("请输入两个整数m,n:\n");//请输入两个整数m,n:
//	scanf_s("%d,%d",&m,&n);//15, 16
//	printf(" greatest common divisor gdc %d %d.\n", m, n);
//	printf("result = : %d\n", gcd(m, n));
//}
// 运行程序: Ctrl + F5 或调试 >“开始执行(不调试)”菜单
// 调试程序: F5 或调试 >“开始调试”菜单
//
// 入门使用技巧: 
//   1. 使用解决方案资源管理器窗口添加/管理文件
//   2. 使用团队资源管理器窗口连接到源代码管理
//   3. 使用输出窗口查看生成输出和其他消息
//   4. 使用错误列表窗口查看错误
//   5. 转到“项目”>“添加新项”以创建新的代码文件，或转到“项目”>“添加现有项”以将现有代码文件添加到项目
//   6. 将来，若要再次打开此项目，请转到“文件”>“打开”>“项目”并选择 .sln 文件
//【第二章】线性表
//线性表是由n个类型相同的数据元素组成的有限序列。(a1,,,,,an).
//数据元素可以是原子类型，也可以是结构类型。线性表中，除了第一个元素a1,每个元素有且仅有一个直接前驱元素
//除了最后一个元素an，ai+1称为ai的直接后继元素。
//
//A-B-C-D-E-F-G-H-I-J-K-L-M-N-O-P-Q-R-S-T-U-V-W-X-Y-Z
//线性表的抽象数据类型
//ADTList
//{
//	数据对象 ：D = {ai | ai(ElemSet，i = 1,2,3,4,5,,,,n)}
//	数据关系 ：R = {<ai + 1,ai> | ai + 1,ai(D),i = 1,2,3,4,5,6,,,,,n}
//	级别操作 ：
//	（1）InitList(&L)
//	初始条件：表L不存在。
//	操作结果：建立一个空的线性表L。
//	（2）ListEmpty(L)
//	初始条件：表L存在。
//	操作结果：若表L为空，返回1，否则返回0。
//	（3）GetElem(L,i,&e)
//	初始条件：表L存在,且i值合法，即1 <= i <= ListLength(L)。
//	操作结果：返回表L的第i个位置元素给e。
//	（4）LocateElem(L,e)
//	初始条件：表L存在,且e为合法元素。
//	操作结果：在表L中查找与给定值e相等的元素。如果查找成功，则返回该蒜素在表中的序号，如果这样的元素不存在，则返回0.
//	（5）InsertList(&L,i,e)
//	初始条件：表L存在，e为合法元素且1<=i<=ListLength(L)。
//	操作结果：返回表L的第i个位置元素给e。
//	（6）DeleteList(&L,i,&e)
//	初始条件：表L存在，e为合法元素且1 <= i <= ListLength(L)。
//	操作结果：删除表L中的第i个位置元素，并用e返回其值。
//	（7）ListLength(L)
//	初始条件：表L存在。
//	操作结果：返回表L的元素个数。
//	（8）ClearList(&L)
//	初始条件：表L存在。
//	操作结果：将表L清空。
//}ADT List
//
//#include<stdio.h>
//#include<iostream>
//#include<stdlib.h>
//struct Result
//{
//	int size;
//};
//void doStruResbyvalye(Result result)
//{
//	result.size = result.size + 200;
//	printf("doStruResbyvalye result = %d\n",result.size);//400
//}
//
//void doStruResbyreference(Result &result)
//{
//	result.size = result.size + 200;
//	printf("doStruResbyreference result = %d\n", result.size);//400
//}
//
//void doStruResbyCONSTreference(const Result& result)
//{
//	printf("doStruResbyCONSTreference result = %d\n", result.size);//400
//}
//
//void doStruResbyCONSTaddress( const Result  *result)
//{
//	//result->size = result->size + 200;  不能修改
//	printf("doStruResbyCONSTaddress result = %d\n", result->size);//400
//}
//
//
//void doStruResbyaddress( Result* result)
//{
//	result->size = result->size + 200;
//	printf("doStruResbyaddress result = %d\n", result->size);//600
//}
//void Exchangebyvalue(int x,int y)
//{
//	int tmp = x;
//	x = y;
//	y = tmp;
//	printf("------[by value] :x = %d y = %d\n\n",x,y);
//}
//void Exchangebyreference(int &x,int &y)
//{
//
//	int tmp = x;
//	x = y;
//	y = tmp;
//	printf("------[by reference] :x = %d y=%d\n\n", x, y);
//}
//
//void Exchangebyaddress(int *x, int *y)
//{
//
//	int tmp = *x;
//	*x = *y;
//	*y = tmp;
//	printf("------[by address] :x = %d y=%d\n\n", *x, *y);
//}
//int main()
//{
//	int a = 3, b = 4;
//	printf("[original]: a= %d  b = %d\n\n",a,b);
//
//	Result  result;
//	result.size = 200;
//	//acccess struct;
//	doStruResbyvalye(result);
//	printf("NOW: doStruResbyvalye result.size = %d\n",result.size);//200
//
//	doStruResbyreference(result);
//	printf("NOW: doStruResbyreference result.size = %d\n", result.size);//400
//
//	doStruResbyCONSTreference(result);//400
//	printf("NOW:doStruResbyCONSTreference  result.size = %d\n", result.size);//400
//
//	doStruResbyCONSTaddress(&result);
//	printf("NOW:doStruResbyCONSTaddress  result.size = %d\n", result.size);//400
//
//	doStruResbyaddress(&result);
//	printf("NOW:doStruResbyaddress  result.size = %d\n", result.size);//600
//
//	Exchangebyvalue(a, b);
//	printf("[byvalueafter ]:a = %d  b = %d\n\n", a, b);
//	Exchangebyreference(a,b);
//	printf("[byreferenceafter ]:a = %d  b = %d\n\n", a, b);
//	Exchangebyaddress(&a, &b);
//	printf("[byreferenceafter ]:a = %d  b = %d\n\n", a, b);
//	return 0;
//}
//[original]: a = 3  b = 4
//
//doStruResbyvalye result = 400
//NOW : doStruResbyvalye result.size = 200
//doStruResbyreference result = 400
//NOW : doStruResbyreference result.size = 400
//doStruResbyCONSTreference result = 400
//NOW : doStruResbyCONSTreference  result.size = 400
//doStruResbyCONSTaddress result = 400
//NOW : doStruResbyCONSTaddress  result.size = 400
//doStruResbyaddress result = 600
//NOW : doStruResbyaddress  result.size = 600
//------[by value] : x = 4 y = 3
//
//[byvalueafter] : a = 3  b = 4
//
//------[by reference] : x = 4 y = 3
//
//[byreferenceafter] : a = 4  b = 3
//
//------[by address] : x = 3 y = 4
//
//[byreferenceafter] : a = 3  b = 4


//
//由于在C语言中，数组具有随机存取的特点，且数组中的元素依次存放在连续的存储空间中，因此，可以采用数组来描述顺序表.
//typedef int DateType
//#define ListSize 100
//typedef struct
//{
//	DateType list[ListSize];
//	int length;//顺序表当前的元素个数.
//}SeqList; //结构体类型名 
//
//
//#include"SeqList.h"
//void DeleteElem(SeqList* A, SeqList* B);
//void main()
//{
//	SeqList A, B;
//	InitList(&A);
//	InitList(&B);
//
//	//INSERT
//	for (int i = 1; i <= 10; i++)
//	{
//		if (0 == InsertList(&A, i, i + 10))
//		{
//			printf("[main]插入A位置不合法%s %s!!!!!!\n", __FUNCTION__, __TIME__);
//			return;
//		}
//	}
//	//INSERT B
//
//	for (int i = 1, j = 1; j <= 6;i += 2, j++)
//	{
//		if (0 == InsertList(&B, j, i * 2))
//		{
//
//			printf("[main]插入B位置不合法%s %s!!!!!!\n", __FUNCTION__, __TIME__);
//			return;
//		}
//	}
//
//	printf("[A]中元素:\n");
//	for (int i = 1; i <= A.length; i++)
//	{
//		DateType value;
//		if (GetElem(A, i, &value) > 0)
//		{
//			printf("%4d", value);
//		}
//
//	}
//	printf("\n[B]中元素:\n");
//	for (int i = 1; i <= B.length; i++)
//	{
//		DateType value;
//		if (GetElem(B, i, &value) > 0)[
//		{
//			printf("%4d", value);
//		}
//	}
//
//	printf("\n[A-B]:\n");
//	DeleteElem(&A,B);
//	for (int i = 1; i <= A.length; i++)
//	{
//		DateType value;
//		if (GetElem(A, i, &value) > 0)
//		{
//			printf("%4d", value);
//		}
//	}
//	printf("\n");
//	[A] 中元素:
//	11  12  13  14  15  16  17  18  19  20
//		[B]中元素 :
//		2   6  10  14  18  22
//		[A - B] :
//		11  12  13  15  17  18  19  20
//
//}
//
//#include<stdio.h>
//#include"SeqList.h"
//void main()
//{
//	SeqList L;
//	InitList(&L);
//	DateType a[] = {-1,2,3,4,-10,-100,200,45,343};
//	int n = sizeof(a) / sizeof(a[0]);
//	for (int i = 1; i <= n; i++)
//	{
//		if (InsertList(&L, i, a[i - 1]) == 0)
//		{
//			printf("[split]插入位置不正确\n");
//			return;
//		}
//	}
//		
//	printf("[L]中元素:\n");
//		
//	for (int i = 1; i <= L.length; i++)
//	{
//		DateType value;
//		if (GetElem(L, i, &value) > 0)
//		{
//			printf("[%4d]", value);
//		}
//	}
//
//	printf("\nAFTER SPLIT\n");
//
//	SplitSeqList(&L);
//
//
//	for (int i = 1; i <= L.length; i++)
//	{
//		DateType value;
//		if (GetElem(L, i, &value) > 0)
//		{
//			printf("[%4d]", value);
//		}
//	}
//
//	[L] 中元素:
//	[-1] [2] [3] [4] [-10] [-100] [200] [45] [343]
//		AFTER SPLIT
//		[-1][-100][-10][4][3][2][200][45][343]
//		D : \C++\data - struct - in - clanguage\DatastructInCLanguage\x64\Debug\DatastructInCLanguage.exe(进程 10656)已退出，代码为 0 (0x0)。
//		要在调试停止时自动关闭控制台，请启用“工具”->“选项”->“调试”->“调试停止时自动关闭控制台”。
//		按任意键关闭此窗口. . .
//}
//
//
//在顺序表中,由于逻辑上相邻的元素其物理位置上叶相邻,因此可以村级存取顺序表中的任何一个元素.
//缺点:插入和删除需要移动大量的元素;顺序表中的存储空间必须事先分配好,而大小可能存在不合适的情况.

//采用链式存储的线性表称为链表,链表可以分为单链表\双向链表\循环链表.
//[数据域]存放数据 [指针域]存放直接后继的存储地址.
//存取链表时,必须从头指针head出发,头指针head指向链表的第一个节点,从头指针head可以找到
//链表中的每一个元素.
//
//typedef struct Node
//{
//	DataType data; //数据域
//	struct Node* next;//后继节点的地址
//}ListNode,*LinkList;
//LinkList L;
//ListNode* L;
//带头节点 ListNode->next = NULL
//不带头节点 L=NULL
//#include<malloc.h>
//#include<stdlib.h>
//#include"LinkList.h"
//void DelElem(LinkList A, LinkList B);
//void main()
//{
//	DateType a[] = {5,7,9,11,15,18,23,35,42,66};
//	DateType b[] = {2,4,7,9,13,18,45,66};
//
//	LinkList A, B;
//	InitList(&A);
//	InitList(&B);
//
//	for (int i = 1; i <= sizeof(a) / sizeof(a[0]); i++)
//	{
//		if (InsertList(A, i, a[i - 1]) == 0)
//		{
//			printf("\n插入位置错误\n");
//			return;
//		}
//	}
//
//	for (int i = 1; i <= sizeof(b) / sizeof(b[0]); i++)
//	{
//		if (InsertList(B, i, b[i - 1]) == 0)
//		{
//			printf("\n插入位置错误\n");
//			return;
//		}
//	}
//	ListNode* p;
//	//输出A 接着输出B
//	printf("\n[A]:\n");
//	for (int i = 1; i <= ListLength(A); ++i)
//	{
//		 p= Get(A, i);
//		if (p)
//			printf("%4d", p->data);
//	}
//	//输出A 接着输出B
//	printf("\n[B]:\n");
//	for (int i = 1; i <= ListLength(B); ++i)
//	{
//		p = Get(B, i);
//		if (p)
//			printf("%4d", p->data);
//	}
//
//	DelElem(A, B);
//	printf("\n[A-B]:\n");
//	for (int i = 1; i <= ListLength(A); ++i)
//	{
//		p = Get(A, i);
//		if (p)
//			printf("%4d", p->data);
//	}
//	printf("\n\n");
//}
//#include <stdio.h>
//
//typedef char (*fun_callback_t)(int number);//声明回调函数指针
//
//fun_callback_t g_fun_cb = NULL;           //定义回调函数指针
//
//int set_callback(fun_callback_t cb);	   //声明设置回调函数
//
//char my_fun(int number)
//{
//	number = number * 100;
//	printf("In {my_fun} number:<%d>\n", number);
//	return 0;
//}
//
//int main()
//{
//	printf("callback test start !\n");
//	set_callback(my_fun);	//设置一个名称为my_fun的回调函数
//
//	for (int i = 0; i < 5; i++)
//	{
//		printf("In {main} i:<%d>\n", i);
//		g_fun_cb(i);		//通过回调函数指针调用回调函数
//		printf("\n");
//	}
//
//	return 0;
//}
//
//int set_callback(fun_callback_t cb) //设置回调函数实现
//{
//	if (g_fun_cb != NULL)
//	{
//		printf("g_fun_cb is not NULL!\n");
//		return 0;
//	}
//	else
//	{
//		g_fun_cb = cb;
//		return 1;
//	}
//}

//
//#include <iostream>
//#include <string>
//#include <memory> // For smart pointers  
//using namespace std;
//
//class Context { };
////Expression 是一个抽象基类，定义了一个纯虚函数 Interpret，所有具体表达式类都需要实现这个函数。
//class Expression {
//public:
//    virtual ~Expression() { }
//    virtual void Interpret(const Context& c) = 0;
//};
////这是一个终结表达式，它包含一个字符串 _statement，并在 Interpret 方法中打印这个字符串。
//class TerminalExpression :public Expression {
//public:
//    TerminalExpression(const string& statement) :_statement(statement){
//      /*  _statement = statement;*/
//    }
//
//    void Interpret(const Context& c) {
//        cout << this->_statement << " -- TerminalExpression" << endl;
//    }
//
//private:
//    string _statement;
//};
////这是一个非终结表达式，它持有一个 Expression 对象和一个整数 _times，在 Interpret 方法中，它会重复调用持有的表达式的 Interpret 方法。
//class NonterminalExpression :public Expression {
//public:
//    NonterminalExpression(unique_ptr<Expression> expression, int times) :
//        _expression(move( expression)),_times(times)
//    {
//       /* _expression = expression;
//        _times = times;*/
//    }
//
//    void Interpret(const Context& c) {
//        for (int i = 0; i < _times; i++) {
//            _expression->Interpret(c);
//        }
//    }
//
//private:
//  //  Expression* _expression;
//    unique_ptr<Expression> _expression; // 使用智能指针 
//    int _times;
//};
//
//int main() {
//    Context c; // 不需要动态分配 
//    auto tp = make_unique<TerminalExpression>("echo"); // 使用智能指针  
//    auto ntp = make_unique<NonterminalExpression>(move(tp), 4); // 使用智能指针  
//  /*  Expression* tp = new TerminalExpression("echo");
//    Expression* ntp = new NonterminalExpression(tp, 4);*/
//    ntp->Interpret(c);
//
//    //delete ntp;
//    //delete tp;
//    //delete c;
//
//    return 0;
//}
//#include <iostream>
//
//// Product
//
//class Product {
//public:
//	virtual ~Product() { }
//	virtual void say() = 0;
//};
//
//class ConcreteProduct :public Product {
//public:
//	ConcreteProduct() {
//		std::cout << "ConcreteProduct..." << std::endl;
//	}
//	void say() {
//		std::cout << "ConcreteProduct Say..." << std::endl;
//	}
//	~ConcreteProduct() { }
//};
//
//// Factory
//
//class Factory {
//public:
//	virtual Product* CreateProduct() = 0;
//	virtual ~Factory() { }
//protected:
//	Factory() { }
//};
//
//class ConcreteFactory :public Factory {
//public:
//	ConcreteFactory() {
//		std::cout << "ConcreteFactory..." << std::endl;
//	}
//
//	~ConcreteFactory() {
//
//	}
//
//	Product* CreateProduct() {
//		return new ConcreteProduct();
//	}
//
//};
//
//// Test
//
//int main() {
//	Factory* factory = new ConcreteFactory();
//	Product* product = factory->CreateProduct();
//	product->say();
//
//	delete factory;
//	delete product;
//
//	return 0;
//}
//ConcreteFactory...
//ConcreteProduct...
//ConcreteProduct Say...
//
//#include <iostream>
//using namespace std;
//
//// Product
//
//class AbstractProduct {
//public:
//    virtual ~AbstractProduct() { }
//    virtual void Operation() = 0;
//    //这是产品 A 和产品 B 的抽象基类。
//    //它声明了纯虚方法 `Operation()，该方法必须由具体产品类实现
//};
//
//class ProductA :public AbstractProduct {
//public:
//    void Operation() {
//        cout << "ProductA Operation" << endl;
//    }
//};
//
//class ProductB :public AbstractProduct {
//public:
//    void Operation() {
//        cout << "ProductB Operation" << endl;
//    }
//};
//
//// Factory
//
//class AbstractFactory {
//public:
//    virtual ~AbstractFactory() { }
//    virtual AbstractProduct* CreateProductA() = 0;
//    virtual AbstractProduct* CreateProductB() = 0;
//    //这是创建产品 A 和产品 B 的工厂的抽象基类。
//    //它声明了纯虚方法 CreateProductA() 和 `CreateProductB()，这些方法必须由具体工厂类实现
//};
//
//class ConcreteFactory :public AbstractFactory {
//public:
//    AbstractProduct* CreateProductA() {
//        return new ProductA();
//    }
//
//    AbstractProduct* CreateProductB() {
//        return new ProductB();
//    }
//    //这是 AbstractFactory 的具体实现。
//    //它提供了 CreateProductA() 和 CreateProductB() 方法的实现，这些方法创建产品 A 和产品 B 的实例。
//};
//
//int main() {
//    AbstractFactory* factory = new ConcreteFactory();
//    AbstractProduct* productA = factory->CreateProductA();
//    AbstractProduct* productB = factory->CreateProductB();
//    productA->Operation();
//    productB->Operation();
//
//    delete factory;
//    delete productA;
//    delete productB;
//
//    return 0;
//}
//ProductA Operation
//ProductB Operation

//#include <iostream>  
//#include <memory>  
//
//// 产品  
//
//class AbstractProduct {
//public:
//    virtual ~AbstractProduct() = default;
//    virtual void Operation() = 0;
//};
//
//class ProductA : public AbstractProduct {
//public:
//    void Operation() override {
//        std::cout << "ProductA Operation" << std::endl;
//    }
//};
//
//class ProductB : public AbstractProduct {
//public:
//    void Operation() override {
//        std::cout << "ProductB Operation" << std::endl;
//    }
//};
//
//// 工厂  
//
//class AbstractFactory {
//public:
//    virtual ~AbstractFactory() = default;
//    virtual std::unique_ptr<AbstractProduct> CreateProductA() = 0;
//    virtual std::unique_ptr<AbstractProduct> CreateProductB() = 0;
//};
//
//class ConcreteFactory : public AbstractFactory {
//public:
//    std::unique_ptr<AbstractProduct> CreateProductA() override {
//        return std::make_unique<ProductA>();
//    }
//
//    std::unique_ptr<AbstractProduct> CreateProductB() override {
//        return std::make_unique<ProductB>();
//    }
//};
//
//int main() {
//    std::unique_ptr<AbstractFactory> factory = std::make_unique<ConcreteFactory>();
//    std::unique_ptr<AbstractProduct> productA = factory->CreateProductA();
//    std::unique_ptr<AbstractProduct> productB = factory->CreateProductB();
//    productA->Operation();
//    productB->Operation();
//    return 0;
//}
//ProductA Operation
//ProductB Operation
//
//#include <iostream>
//using namespace std;
//
//class Subject {
//public:
//    virtual void Request() = 0;
//    virtual ~Subject() { }
//    //这是代理模式中的抽象主题接口。
//    //它声明了一个纯虚方法 Request()，用于定义原型的行为。
//};
//
//class ConcreteSubject :public Subject {
//public:
//    void Request() {
//        cout << "ConcreteSubject::Request..." << endl;
//    }
//    //这是代理模式中的具体主题类。
//    //它实现了 Subject 接口的 Request() 方法，用于定义原型的具体行为。
//};
//
//class Proxy {
//public:
//    Proxy(Subject* subject) {
//        _sub = subject;
//    }
//
//    void Reuqest() {
//        cout << "Proxy::Request..." << endl;
//        _sub->Request();
//    }
//    //这是代理模式中的代理类。
//    //它维护一个指向具体主题的指针，用于控制对具体主题的访问。
//    //它实现了 Request() 方法，用于提供对具体主题的访问。
//
//private:
//    Subject* _sub;
//};
//
//int main() {
//    Subject* sub = new ConcreteSubject();
//    Proxy* p = new Proxy(sub);
//    p->Reuqest();
//
//    delete sub;
//    delete p;
//
//    return 0;
//}
//代理模式的工作流程
//
//客户端创建一个具体主题的实例。
//客户端创建一个代理的实例，并将具体主题的实例传递给代理。
//客户端请求代理的 Request() 方法。
//代理的 Request() 方法调用具体主题的 Request() 方法。
//具体主题的 Request() 方法执行具体的行为。

// Master  
// Master
//#include <iostream>  
//#include <memory>  
//
//// Slave  
//class Slave {
//public:
//    void sendMessage(const std::string& message) {
//        std::cout << "Slave received message: " << message << std::endl;
//    }
//};
//
//// Proxy  
//class Proxy {
//public:
//    Proxy(Slave* slave) : slave_(slave) {}
//
//    void sendMessage(const std::string& message) {
//        slave_->sendMessage(message);
//    }
//
//private:
//    Slave* slave_;
//};
//
//// Master  
//class Master {
//public:
//    Master(std::unique_ptr<Proxy>&& proxy) : proxy_(std::move(proxy)) {}
//
//    void sendMessage(const std::string& message) {
//        proxy_->sendMessage(message);
//    }
//
//private:
//    std::unique_ptr<Proxy> proxy_;
//};
//
//int main() {
//    auto slave = std::make_unique<Slave>();
//    auto proxy = std::make_unique<Proxy>(slave.get());
//    auto master = std::make_unique<Master>(std::move(proxy));
//
//    master->sendMessage("Hello, Slave!");
//
//    return 0;
//}

//#include <iostream>  
//#include <queue>  
//
//int main() {
//    std::queue<int> q;
//
//    // 添加任务到队伍  
//    for (int i = 0; i < 2000; i++)
//    {
//        q.push(i);
//    }
//
//    // 处理任务  
//    while (!q.empty()) {
//        int task = q.front();
//        std::cout << "处理任务 " << task << std::endl;
//        q.pop();
//    }
//
//    return 0;
//}
//#include <stdio.h>  
//#include <stdlib.h>  
//#include <unistd.h>  
//#include <fcntl.h>  
//#include <sys/stat.h>  
//
//int main() {
//    // 创建FIFO命名管道  
//    mkfifo("fifo", 0644);
//
//    // 父进程写入FIFO命名管道  
//    int fd = open("fifo", O_WRONLY);
//    if (fd < 0) {
//        perror("open");
//        exit(1);
//    }
//    char* msg = "Hello, 子进程!";
//    write(fd, msg, strlen(msg));
//    close(fd);
//
//    // 子进程读取FIFO命名管道  
//    pid_t pid = fork();
//    if (pid == 0) {
//        fd = open("fifo", O_RDONLY);
//        if (fd < 0) {
//            perror("open");
//            exit(1);
//        }
//        char buffer[256];
//        read(fd, buffer, 256);
//        printf("子进程接收到的消息：%s\n", buffer);
//        close(fd);
//    }
//    else {
//        wait(NULL);
//    }
//
//    return 0;
//}
//
//#include <iostream>  
//#include <queue>  
//
//// 定义结构体  
//struct Task {
//    int id;
//    std::string name;
//};
//
//int main() {
//    // 创建一个队列  
//    std::queue<Task> q;
//
//    // 添加任务到队伍  
//    Task task1 = { 1, "任务1" };
//    Task task2 = { 2, "任务2" };
//    Task task3 = { 3, "任务3" };
//
//    q.push(task1);
//    q.push(task2);
//    q.push(task3);
//
//    // 处理任务  
//    while (!q.empty()) {
//        Task task = q.front();
//        std::cout << "处理任务 " << task.id << "： " << task.name << std::endl;
//        q.pop();
//    }
//
//    return 0;
//}
//
//#include <stdio.h>  
//#include <stdlib.h>  
//#include <unistd.h>  
//#include <fcntl.h>  
//#include <sys/stat.h>  
//#include <string.h>  
//#include <sys/wait.h>  
//
//int main() {
//    // 创建FIFO命名管道  
//    mkfifo("fifo", 0644);
//
//    // 父进程写入FIFO命名管道  
//    int fd = open("fifo.1", O_WRONLY);
//    if (fd < 0) {
//        perror("open");
//        exit(1);
//    }
//    char* msg = "Hello, child process!!";
//    write(fd, msg, strlen(msg));
//
//    // 子进程读取FIFO命名管道  
//    pid_t pid = fork();
//    if (pid == 0) {
//        fd = open("fifo.1", O_RDONLY);
//        if (fd < 0) {
//            perror("open");
//            exit(1);
//        }
//        char buffer[256];
//        read(fd, buffer, 256);
//        printf("child recv msg:%s\n", buffer);
//        close(fd);
//        _exit(0);
//    }
//    else {
//        // 父进程等待子进程读取后再关闭写入端  
//        wait(NULL);
//        close(fd);
//    }
//
//    return 0;
//}
//
//maverick@DESKTOP - 42SRDNB: / home / ftp / embeded - linux - c$ gcc - o fif fif.c
//maverick@DESKTOP - 42SRDNB: / home / ftp / embeded - linux - c$ . / fif fifo.1
//child recv msg : Hello, child process!!
//maverick@DESKTOP - 42SRDNB: / home / ftp / embeded - linux - c$